<!DOCTYPE html>
<html>

	<head>
		<meta charset="utf-8" />
		<title></title>
	</head>

	<body>

	</body>

</html>
<script type="text/javascript">
	//题1
	//	if(false){
	//		var a = 1;
	//		let b = 2;
	//	}
	//	console.log(a);   //undefined
	//	console.log(b);   //b is not...
	//	var不会产生块级作用域   __let会产生块级作用域
	//	执行代码如下 
	//	var a;-
	//	if(false){
	//		a = 1;
	//		let b = 2;
	//	}
	//	console.log(a);   //undefined
	//	console.log(b);   //b is not...




	//题2
	//	var a = 1;
	//	if(true){ 
	//		console.log(a);    //报错  beforeroor
	//		let a = 20;
	//		
	//	}    
	//let声明的变量不会提升 ，暂时性死去  (在let上log报错before。。。。)
	//在let 声明变量之前访问变量会抛出错误





	//题3
	var a = [1, 2, 3];
	console.log(a.join())
	//将数组转为字符串
	//转字符串1，2，3  join转字符串儿
	//join方法如果省略参数，默认以点，分隔 join(':') 




	//题4
	console.log(0.1 + 0.2)
	//小数儿  0.30000000000000004
	console.log(0.1 + 0.2 == 0.3);
	//而 log(0.2-0.1) //0.1
	//false 





	//题5
	console.log(Boolean(false)) //false
	console.log(Boolean('0'))   //true  在判断里面0为真值
	console.log(Boolean(''))    //false 空为false
	console.log(Boolean(NaN))   //false ..







	//题6
	var str = '123qwe'
	console.log(typeof str++) //number
	//使用到++运算符时如果变量不是数字类型 
	//会首先用到Number 转换为数字
	//typeof str++  相当于typeof NUmber(str)++
	//后置的++是先取值后计算






	//转换规则
	//	 Boolean（布尔判断）  
	//                  true 真（成立）     false 假（不成立）
	//                   转换规则：
	//                                true                 false
	//                   Number       除了0/NaN             0/NaN
	//                   string       非空字符串            空字符串
	//                   null         所有对象              空对象
	//                   undefined    不存在                undefined










	//题6
	//      ==和== 的区别
	//      ==   判断两个值是否相等 (类型转换)
	//      ===  判断两个值的数据类型和值是否相等
	var a = 1;
	var b = '1';
	console.log(a == b) //true
	console.log(a === b) //false  在这里进行了一个类型比较 str num







	//题7 
	// var a= []    //数组创建.
	// var b= [] 
	// console.log(a==b)   
	// false 这个东西创建的地址不同所以是假






	//题8
	var arr = [20, 30, 40]
	var num = 100
	function f1(n = 100, a = 300) {
		console.log(arguments[2] * num) //4000
	//arguments所有形参集合(下标加项)	
	}
	f1(...arr)   //拓展运算符...在这里相当于把[20,30,40] **下面的实参
	//相当于 f1(20,30,40)
	//函数参数默认值 如果有就用默认的 传递了就用传递
	









   





	//	//题11
	//	var arr = [2,3,4,5,5,6,8]
	//	function f2(a,n,...arr){
	//		console.log(arr[8]*n)
	//	}
	//	f2(num,...arr)     
	//  NaN 该返回一个数   但是到第8个时 没参
	//  拓展运算符    ...展开容器
	//  ...rset参数            
	//  let arr = [1,2,3]  //1,2,3   变序列





	//题12
	//变量提升
	console.log(na)
	var na = '你么你么'; //undeined
	//挂在全局window上面 
	//console.log(window.name)
	//js代码执行顺序 两部
	//js代码 1解析 2执行
	//浏览器解析遇到var function 提升到作用域的最前面 
	//变量提升指挥提升变量名的声明，而不会提升变量的赋值初始值
	//函数提升的优先级>变量提升的优先级，即函数提升在变量提升之上 	




	//题13 
	//声明覆盖
	var name1 = '我我哦我我我';
	var name2 = '你ininin'
	console.log(name2) // 你ininin
	//var 会变量覆盖
	//题14
	//var 没有块级作用域


// var举例
	function fn2() {
		for(var i = 0; i < 5; i++) {
			console.log(i) //0 1 2 3 4
		}
		console.log(i)   //5
	}
	fn2();  


// let举例
	function fn2() {
		for(let i = 0; i < 5; i++) {
			console.log(i)
		}
		console.log(i)   //Error: i is not defined   let被限制在{}里 W
	}
	fn2(); 
	// 为什么不在用 var 定义变量了  
	// 因为ver 会变量提升 会被声明覆盖  还没有块级作用域







	//题 15
	//	let name3 = '鱼';
	//  let name3 = '水';
	//	console.log(name3)   // 抱错 let不可以重复定义






	//题16 
	//常量一经定义不可修改   规范声明常量时一般大写
	const CL = '鱼'; //  堆 栈  常量存在池中





	//题17 
	//默认参数                          //下面形参在这里有所有会优先输出
	function findGF(gf1, gf2 = '迪丽热巴') {
		//gf2?gf2=gf2:gf2='迪丽热巴'     //等同于这行
		console.log('第一个女朋友' + gf1) //第一个女朋友玉米
		console.log('第二个女朋友' + gf2) //第二个女朋友迪丽热巴
	}
	findGF('玉米')                       //即函数参数的默认值








	//题18 模板字符串
	//模板对象   `` 反引号   属es6 新曾属性
	// let str1 = '穿堂而过的'
	// let str2 = '风'
	// let newstr =`我是${str1}${str2}`
	// 等同于 es5  let newstr = '我是'+str1 + str2 ;
	// console.log(newstr)             //我是穿堂而过的风
	// var a = 10;
	// var s = `hello ${a} world`;
	// var s1 = 'hello '+a+' world';    //hellow 10 world




	//题19
	//解构赋值  (解开结构操作容器)
	//	let obj = {
	//		className: '卡西诺',
	//		age : 18
	//	}




	//题20
	//占位符，，，
	//	var arr = ['小王', '小曾', '小李', '小袁'];
	//	var [, , one] = arr;
	//	console.log(one) //小李




		//附加题
	//	let newVal = ((a, b) => {
	//		return a + b
	//	})(10, 20)
	//	console.log(newVal) // 30 
	//	console.log(`newVal = ${newVal}`) // newVal = 30






	
	//题21
	//假设一个变量a ？什么情况下a！==a  成立     
	//a！==a log(false)
	//a取值为NaN时为true



	
	
	
	



    //题24
	for(var i=0;i<=20;i+=5){
		console.log(i)  	// 0 5 10 15 20  从右边走运行  i的最大取值为<=20
   		}                   //i一次走+5
   		console.log(i)      // 25
   	
   	 
   	 
    //题25
   	var z;
        function f(a,b){
        return function(){
        z = a * b;
       }
        }
        console.log(f(2,3)());    //undefiend
        console.log(z);           //  6
    
	
		
    
    //题26
   	var str = 'javascript'.slice(0,4);
    console.log(str);        //jave
    //字符串截取下标0—4
    
    
    
    //题27
	   var array = [1,2,3,4,5,6,7,8,9,10],
	    sum = 0;
		while(array.length){
			sum += Math.max.apply(this, array.splice(0,3));
		}
    console.log(sum);    //28    3+6+9+10
    //每次截取三个值 三个值中最大的再相加  
    
	
	



    //题X
    //ajax.js 手写ajax源码4步骤
//   1创建Ajax对象
//   var xhr = window.XMLHttpRequest?new XMLHttpRequest():new ActiveXObject('Microsoft.XMLHTTP');// 兼容IE6及以下版本//
//   2：配置 Ajax请求地址
//   xhr.open('get','url',true);//
// 	 3：发送请求
// 	 xhr.send(null); // 严谨写法//
//	 4:监听请求，接受响应
//	 xhr.onreadysatechange=function(){ if(xhr.readySates==4&&xhr.status==200 || xhr.status==304 ) console.log(xhr.responsetXML)}

    
    

   
    

	

	// 改造函数  输出3
	var fnArr = []
	for (var  i=0;i<10;i++){
		fnArr[i]=function (){
			return i
		}
	}
	console.log(fnArr[3]())  //10





//					var a = 1;
//					setTimeout(function() {
//						a = 2;			
//						console.log(a);// 2
//					注意定时器是有默认值的
//					}, 0);
//					var a;
//					console.log(a); //1
//					a = 3;
//					console.log(a);  //3  作用域链  一层一层
				

	
	
	



	
	// 叫他只输出 正值
	// 写⼀个函数，操作数组，返回⼀个新数组，新数组中只包含正数。 
			// 方法1
	//				  function filterPositive(arr) {       
	//				  	// 补全    
	//				  	var arr1 = []
	//				  	arr.forEach(function (item){
	//				  		if(item>0&&typeof item=='number'){  //在这里检测一下
	//				  			arr1.push(item)
	//				  		}
	//				  	})
	//				  	console.log(arr1)
	//				  	}    
	//				  	var arr = [3, -1, 2, true]   
	//				  	filterPositive(arr)    
	//				  	console.log(filterPositive(arr)) // [3, 2]
			//方法2
				//	function filterPositive(arr) {
				//		//补全   
				//      在这里使用了过滤
				//		return arr.filter(item => {
				//			return typeof item == 'number' && item > 0
				//		})
				//	}
				//	var arr = [3, -1, 2, true]
				//	filterPositive(arr)
				//	console.log(filterPositive(arr)) //[3, 2]



				
// sort()数组的排序；返回值：无(在原先数组里进行排序操作)
//                    升序
//                         var arr=[1,2,3,4,5,6];
//                         var arr1=arr.sort(function(a,b){
//                                 return a-b
//                         })
//                         console.log(arr1)
//                          console.log(arr)。	
//                    降序
//                         var arr=[1,2,3,4,5,6];
//                         var arr1=arr.sort(function(a,b){
//                                 return b-a
//                         })
//                         console.log(arr1)
//                   给数组随机排序  出现 一个随机数
//                         var arr=[1,2,3,4,5,6];
//                         var arr1=arr.sort(function(a,b){
//                                 return Math.random()-Math.random()
//                         })
//                         console.log(arr1)







// function fn(a,b){
//              for(var i=0;i<arguments.length;i++){
//          console.log(arguments[i])   //就是指的所有的i
//                              }       //arguments 所有形参集合
//                      }
//                      fn(10,20)      	 // 10 20 
//                 







//箭头函数  简化了函数的定义 省略了关键字function
		//let f = v =>v;  //es6
		//                //es5
		//              
		//  var f = function (v){
		//  	return v
		//  };
//	let f = ()=>123  //没有参数






//		面试题 去重后  再返回数组
//		set 转换为数组
//		var arr5 = [1, 2, 2, 3, 4, 4, 4, 4, 2, 2, 2, '2'];
//				//		var arr6 = new Set(arr5)
//				//		console.log(arr6) // {1 2 3 4 '2'}

//				//		var arr7 = Array.from(arr6)
//				//		console.log(arr7) //[1, 2, 3, 4, "2"]
//
//		var arr8 = [...new Set(arr5)]
//		console.log(arr8) //[1, 2, 3, 4, "2"]







	            //  var length = 10;
				//	function fn(){
				//		console.log(this.length)  // 10 
				//	}
				//	
				//	var obj = {
				//		length: 5,
				//		mathod: function(fn){
				//			fn()                  //10
				//			arguments[0]()        //2!  这里的指向了 长度
				//		}
				//	}
				//	obj.mathod(fn,1)






//题X
	// var obj1 = { a: 1, b: 2 }
	// var obj2 = { a: 1, b: 2 }
	// console.log(obj1 == obj2) //false  地址不同
	// console.log(obj1 = obj2)  //true {a:1,b:2}  赋值右赋左
	// console.log(obj1 == obj2) //true


	

//题X
   //平方根的问题  即自己乘自己
   //补全代码  求原数组的*3   让它log出//[9,16,36]
  var arr = [3, 4, 6]
  function fn() {
        //方法1
			for (var i = 0; i < arr.length; i++) {
			arr[i] *= arr[i]    //就等于 arr[i]=arr[i]*arr[i]
			}
		}
  fn()

  console.log(arr) //[9,16,36]
		//方法2
				//var arr = [3,6,9]
				//var rel = arr.map(function (item){
				//	return item*item
				//})
				//console.log(rel)
		// 方法儿3
				// var arr1 = []
				// arr.forEach(function(item){
				// 	arr1.push(item*item)
				// })
				// console.log(arr1)
		//方法3
    			//console.log([1, 2, 3].map(x => x * x));     //1 4 9





 //题
   //拓张运算符...
	// const arr1 = [1, 2, 3]
	// const arr2 = [4, 5, 6]
	// const arr3 = [7, 8, 9, ...arr1, ...arr2]
	// console.log(arr3)     // 789 123 456 
	// console.log(...arr1)  // 123






</script>